package pe.com.cotelasa.scp.controlador;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.faces.event.ActionEvent;
import javax.inject.Inject;
import javax.inject.Named;

import org.apache.log4j.Logger;
import org.primefaces.event.DateSelectEvent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;

import pe.com.cotelasa.common.controlador.MBGenerico;
import pe.com.cotelasa.scp.common.IObserver;
import pe.com.cotelasa.scp.controlador.backingBean.BKDetalleOrdenCompraServicio;
import pe.com.cotelasa.scp.controlador.backingBean.BKOrdenCompra;
import pe.com.cotelasa.scp.controlador.comando.ComandoActualizar;
import pe.com.cotelasa.scp.controlador.comando.ComandoGuardar;
import pe.com.cotelasa.scp.dominio.common.Constantes;
import pe.com.cotelasa.scp.dominio.service.IServicioDetalleOrdenCompraServicio;
import pe.com.cotelasa.scp.dominio.service.IServicioOrdenCompraServicio;
import pe.com.cotelasa.scp.dominio.service.IServicioOrdenPedido;
import pe.com.cotelasa.scp.dominio.service.IServicioTipoMoneda;
import pe.com.cotelasa.scp.dominio.service.IServicioCategoriaArticulo;
import pe.com.cotelasa.scp.dominio.service.IServicioProveedor;
import pe.com.cotelasa.scp.dominio.service.IServicioSede;
import pe.com.cotelasa.scp.dominio.service.IServicioContacto;
import pe.com.cotelasa.scp.dominio.service.IServicioCorrelativoDocumento;
import pe.com.cotelasa.scp.dominio.service.IServicioTipoDocumento;
import pe.com.cotelasa.scp.dominio.common.ESTADO_REGISTRO;
import pe.com.cotelasa.scp.dominio.common.URLPaginacion;
import pe.com.cotelasa.scp.dominio.excepcion.ServiceException;
import pe.com.cotelasa.scp.dominio.common.util.UtilitarioFecha;
import pe.com.cotelasa.scp.dominio.service.IServicioArticulo;
import pe.com.cotelasa.scp.dominio.service.IServicioComposicionArticulo;
import pe.com.cotelasa.scp.dominio.service.IServicioIgv;
import pe.com.cotelasa.scp.dominio.service.IServicioParametro;
import pe.com.cotelasa.scp.dominio.service.IServicioTipoFormaPago;
import pe.com.cotelasa.scp.entidad.Articulo;
import pe.com.cotelasa.scp.entidad.CategoriaArticulo;
import pe.com.cotelasa.scp.entidad.ComposicionArticulo;
import pe.com.cotelasa.scp.entidad.Contacto;
import pe.com.cotelasa.scp.entidad.CorrelativoDocumento;
import pe.com.cotelasa.scp.entidad.Sede;
import pe.com.cotelasa.scp.entidad.DetalleOrdenCompraServicio;
import pe.com.cotelasa.scp.entidad.DetallePedidoOp;
import pe.com.cotelasa.scp.entidad.OrdenCompraServicio;
import pe.com.cotelasa.scp.entidad.OrdenPedido;
import pe.com.cotelasa.scp.entidad.ParametroDetalle;
import pe.com.cotelasa.scp.entidad.Proveedor;
import pe.com.cotelasa.scp.entidad.TipoDocumento;
import pe.com.cotelasa.scp.entidad.TipoMoneda;
import pe.com.cotelasa.scp.to.ProveedorTO;
import pe.com.cotelasa.seguridad.controlador.backingBean.BKSession;

/**
 * @author usuario
 */
@Named(value = "MBOrdenCompra")
@Scope("request")
public class MBOrdenCompra extends MBGenerico implements IMantenedor, IObserver, Serializable {

    private static final long serialVersionUID = -3008828663507135743L;
    private static Logger logger = Logger.getLogger(MBOrdenCompra.class);
    @Inject
    private BKOrdenCompra bkOrdenCompra;
    @Inject
    private IServicioOrdenCompraServicio servicioOrdenCompra;
    @Inject
    private IServicioTipoMoneda servicioTipoMoneda;
    @Inject
    private IServicioOrdenPedido servicioOrdenPedido;
    @Inject
    private IServicioComposicionArticulo servicioComposicionArticulo;
    @Inject
    private IServicioProveedor servicioProveedor;
    @Inject
    private IServicioDetalleOrdenCompraServicio servicioDetalleOrdenCompra;
    @Inject
    private IServicioContacto servicioContacto;
    @Inject
    private IServicioSede servicioSede;
    @Inject
    private IServicioCorrelativoDocumento servicioCorrelativo;
    @Inject
    private IServicioTipoDocumento servicioTipoDocumento;
    @Inject
    private IServicioCategoriaArticulo servicioCategoria;
    @Inject
    private BKDetalleOrdenCompraServicio bkDetalleOrdenCompraServicio;
    @Inject
    private IServicioIgv servicioIgv;
    @Inject
    private IServicioArticulo servicioArticulo;
    @Inject
    private IServicioTipoFormaPago servicioFormaPago;
    @Inject
    private IServicioParametro servicioParametro;
    @Inject
    private MBCompBuscarDireccion mbSede;
    @Inject
    private MBComponenteFindProveedor mbComponenteFindProveedor;
    @Autowired
    BKSession session;

    public MBOrdenCompra() {
    }

    public void buscarArticulosCompPorPedidoTela(OrdenPedido ordenPedido) {

        try {
            this.bkOrdenCompra.setListaArticuloComp(new ArrayList<Articulo>());
            String modelo = "";
            for (DetallePedidoOp detalleOP : ordenPedido.getDetallePedidoOpCollection()) {
                if (detalleOP.getEstadoRegistro() == ESTADO_REGISTRO.ACTIVO.getValor()) {
                    ComposicionArticulo composicion = new ComposicionArticulo();
                    composicion.setIdArticulo(detalleOP.getIdArticulo());
                    this.bkOrdenCompra.getListaArticuloComp().add(detalleOP.getIdArticulo());
                    Collection<ComposicionArticulo> listaComposicion = servicioComposicionArticulo.buscarComposicionPorArticulo(composicion);

                    Iterator itr = listaComposicion.iterator();
                    //if (!modelo.equalsIgnoreCase(detalleOP.getIdArticulo().getModelo())) {
                    while (itr.hasNext()) {
                        ComposicionArticulo comp = (ComposicionArticulo) itr.next();
                        /*if(){
                        
                        
                        
                         }*/
                        if (this.bkOrdenCompra.getListaArticuloComp().contains(comp.getIdArticuloComp())) {
                        } else {
                            this.bkOrdenCompra.getListaArticuloComp().add(comp.getIdArticuloComp());
                            ComposicionArticulo composicion1 = new ComposicionArticulo();
                            composicion1.setIdArticulo(comp.getIdArticuloComp());
                            Collection<ComposicionArticulo> listaComposicionAdd = servicioComposicionArticulo.buscarComposicionPorArticulo(composicion1);
                            itr.remove();
                            if (listaComposicionAdd.size() > 0) {
                                listaComposicion.addAll(listaComposicionAdd);
                            }
                            itr = listaComposicion.iterator();
                        }

                    }
                    modelo = detalleOP.getIdArticulo().getModelo();
                }
                //}
            }

            /*for (Articulo a : this.bkOrdenCompra.getListaArticuloComp()) {
             System.out.println("nombre articulo: " + a.getNombreComercial());
             }*/
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al cargar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
    }

    public void buscarArticulosCompPorPedidoPrenda(OrdenPedido ordenPedido) {

        try {
            this.bkOrdenCompra.setListaArticuloComp(new ArrayList<Articulo>());
            String modelo = "";
            for (DetallePedidoOp detalleOP : ordenPedido.getDetallePedidoOpCollection()) {
                if (detalleOP.getEstadoRegistro() == ESTADO_REGISTRO.ACTIVO.getValor()) {
                    ComposicionArticulo composicion = new ComposicionArticulo();
                    composicion.setIdArticulo(detalleOP.getIdArticulo());
                    this.bkOrdenCompra.getListaArticuloComp().add(detalleOP.getIdArticulo());
                    Collection<ComposicionArticulo> listaComposicion = servicioComposicionArticulo.buscarComposicionPorArticulo(composicion);

                    Iterator itr = listaComposicion.iterator();
                    if (!modelo.equalsIgnoreCase(detalleOP.getIdArticulo().getModelo())) {
                        while (itr.hasNext()) {
                            ComposicionArticulo comp = (ComposicionArticulo) itr.next();

                            if (this.bkOrdenCompra.getListaArticuloComp().contains(comp.getIdArticuloComp())) {
                            } else {
                                this.bkOrdenCompra.getListaArticuloComp().add(comp.getIdArticuloComp());

                            }
                            if (!comp.getIdArticuloComp().getIdCategoriaArticulo().getNombre().contains("TELA")) {
                                ComposicionArticulo composicion1 = new ComposicionArticulo();
                                composicion1.setIdArticulo(comp.getIdArticuloComp());
                                Collection<ComposicionArticulo> listaComposicionAdd = servicioComposicionArticulo.buscarComposicionPorArticulo(composicion1);
                                itr.remove();
                                if (listaComposicionAdd.size() > 0) {
                                    listaComposicion.addAll(listaComposicionAdd);
                                }
                                itr = listaComposicion.iterator();
                            }
                        }
                        modelo = detalleOP.getIdArticulo().getModelo();
                    }
                }
            }

            /*for (Articulo a : this.bkOrdenCompra.getListaArticuloComp()) {
             System.out.println("nombre articulo: " + a.getNombreComercial());

             }*/
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al cargar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
    }

    public void buscarListaOrdenCompras() {

        OrdenCompraServicio objOrdenCompra = this.bkOrdenCompra.getOrdenCSBusqueda();
        objOrdenCompra.setIdOrdenPedido(bkOrdenCompra.getOrdenPedidoBusqueda());

        /*if (objOrdenCompra.getIdOrdenPedido() == null) {
         objOrdenCompra.setIdOrdenPedido(new OrdenPedido());
         }*/
        //objOrdenCompra.getIdOrdenPedido().setIdEmpresa(session.getEmpresa());
        objOrdenCompra.setTipo(bkOrdenCompra.getTipoOrden());

        try {
            bkOrdenCompra.setListaOrdenCompraActivos(
                    servicioOrdenCompra.buscarOrdenCompraServiciosPorFiltro(objOrdenCompra, bkOrdenCompra.getFechaInicio(), bkOrdenCompra.getFechaFinal()));

            for (OrdenCompraServicio orden : bkOrdenCompra.getListaOrdenCompraActivos()) {
                System.out.println(orden.getIdOrdenPedido());
            }


        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al cargar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
    }

    public void buscarListaOrdenComprasAntiguas() {
        OrdenCompraServicio objOrdenCompra = this.bkOrdenCompra.getOrdenCSBusqueda();
        objOrdenCompra.setEstadoOrden("" + OrdenCompraServicio.ESTADO_ORDEN_SC.BORRADOR.getValor());
        objOrdenCompra.setIdOrdenPedido(bkOrdenCompra.getOrdenPedidoBusqueda());
        objOrdenCompra.setTipo(bkOrdenCompra.getTipoOrden());
        String[] listaEsdado = {"" + OrdenCompraServicio.ESTADO_ORDEN_SC.ANULADO.getValor(),
            "" + OrdenCompraServicio.ESTADO_ORDEN_SC.BORRADOR.getValor()};
        try {
            bkOrdenCompra.setListaOrdenCompraActivos(servicioOrdenCompra.listarOrdenCSConCodigoPorOP(objOrdenCompra, listaEsdado));
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al cargar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
    }

    public String mostrarMantenimiento() {
        try {
            bkOrdenCompra.setTipoOrden('C');
            bkOrdenCompra.setOrdenPedidoBusqueda(new OrdenPedido(-1));
            bkOrdenCompra.setOrdenCSBusqueda(new OrdenCompraServicio());
            bkOrdenCompra.getOrdenCSBusqueda().setEstadoOrden("");
            bkOrdenCompra.getOrdenCSBusqueda().setDescripcion("");
            bkOrdenCompra.getOrdenCSBusqueda().setCodigo("");
            bkOrdenCompra.getOrdenCSBusqueda().setIdEmpresa(session.getEmpresa());
            bkOrdenCompra.getOrdenCSBusqueda().setIdProveedor(new Proveedor());
            bkOrdenCompra.getOrdenCSBusqueda().getIdProveedor().setRazonSocial("");
            bkOrdenCompra.getOrdenCSBusqueda().setIdCategoriaArticulo(new CategoriaArticulo(0));
            bkOrdenCompra.setListaOrdenCompraActivos(null);
            OrdenPedido ordenp = new OrdenPedido();
            ordenp.setIdEmpresa(session.getEmpresa());
            bkOrdenCompra.setListaOrdenesPedido(servicioOrdenPedido.listarOrdenesPedidoActivosPorEmpresa(ordenp));
            bkOrdenCompra.setListaCategoriaPadre(servicioCategoria.listarCategoriasPadres());
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al actualizar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }


        return URLPaginacion.OrdenCompraServicio.URL_LISTA_ORDEN_COMPRA;
    }

    public String nuevo() {

        this.bkOrdenCompra.setComando(new ComandoGuardar(this));
        mbSede.addObserver(this);
        mbComponenteFindProveedor.clearObserver();
        mbComponenteFindProveedor.addObserver(this);
        cargarCombo();
        OrdenPedido ordenp = new OrdenPedido();
        ordenp.setEstadoPedido("E");
        ordenp.setIdEmpresa(session.getEmpresa());
        bkOrdenCompra.inicializarBean();
        bkOrdenCompra.getOrdenCompraFormulario().setIdOrdenPedido(new OrdenPedido());
        bkOrdenCompra.getOrdenCompraFormulario().setIdCategoriaArticulo(new CategoriaArticulo());
        bkOrdenCompra.getOrdenCompraFormulario().getIdCategoriaArticulo().setId(0);
        bkOrdenCompra.getOrdenCompraFormulario().setIdTipoMoneda(new TipoMoneda());
        bkOrdenCompra.getOrdenCompraFormulario().getIdTipoMoneda().setId(0);
        bkOrdenCompra.getOrdenCompraFormulario().setIdEmpresa(session.getEmpresa());
        bkOrdenCompra.getOrdenCompraFormulario().setCodigo("");
        bkOrdenCompra.getOrdenCompraFormulario().setCrearPartidas((short) 0);
        bkOrdenCompra.getOrdenCompraFormulario().setEsImportacion((short) 0);
        try {
            bkOrdenCompra.setListaOrdenesPedido(servicioOrdenPedido.listarOrdenesPedidoPorEstado(ordenp));
            //System.out.println("lista de ops: "+bkOrdenCompra.getListaOrdenesPedido());
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al guardar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
        return URLPaginacion.OrdenCompraServicio.URL_FORMULARIO_ORDEN_COMPRA;
    }

    public String editar() {
        this.bkOrdenCompra.setComando(new ComandoActualizar(this));
        mbSede.addObserver(this);
        mbComponenteFindProveedor.clearObserver();
        mbComponenteFindProveedor.addObserver(this);
        bkOrdenCompra.setOrdenCSAntigua(null);
        try {
            bkOrdenCompra.setOrdenCompraFormulario(
                    servicioOrdenCompra.conseguirOrdenCompraServicioPorId(bkOrdenCompra.getOrdenCompraFormulario().getId()));
            /*if(bkOrdenCompra.getOrdenCompraFormulario().getIdOrdenPedido() == null){
             bkOrdenCompra.getOrdenCompraFormulario().setIdOrdenPedido(new OrdenPedido());
             }*/
            OrdenCompraServicio orden = bkOrdenCompra.getOrdenCompraFormulario();
            cargarCombo();
            iniciarEdicion(orden);
            elegirOP();
            seleccionarSubCategoria();
            elegirProveedor();
            bkOrdenCompra.setEstadoOrdenCompraServicio(orden.getEstadoOrden());

        } catch (ServiceException e) {
            e.printStackTrace();
            mostrarError("Ocurrieron algunos problemas al guardar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
        return URLPaginacion.OrdenCompraServicio.URL_FORMULARIO_ORDEN_COMPRA;
    }

    public void iniciarEdicion(OrdenCompraServicio orden) {

        try {

            Sede sede = new Sede();
            sede.setIdProveedor(orden.getIdProveedor());
            sede.setSedeAdministradora(1);
            bkOrdenCompra.setListaContacto(
                    servicioContacto.buscarContactosPorSede(
                    servicioSede.buscarSedeAdministradora(sede)));

            bkOrdenCompra.setListaTemporalDetalleOrdenCompraServicio(new ArrayList<DetalleOrdenCompraServicio>());
            bkOrdenCompra.setListaDetalleOrdenCompraServicio(new ArrayList<DetalleOrdenCompraServicio>());

            inicializarDetallesOrdenCS(servicioDetalleOrdenCompra.listarDetallesPorOrden(orden));
            bkOrdenCompra.setListaTipoPago(new ArrayList<String>());
            for (ParametroDetalle param : servicioParametro.listarTipoPago(orden.getFormaPago().getNombre())) {
                bkOrdenCompra.getListaTipoPago().add(param.getValCadena());
            }

        } catch (ServiceException e) {
            e.printStackTrace();
            mostrarError("Ocurrieron algunos problemas al guardar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
    }

    public void inicializarDetallesOrdenCS(Collection<DetalleOrdenCompraServicio> lista) throws ServiceException {


        for (DetalleOrdenCompraServicio detalle : lista) {
            DetalleOrdenCompraServicio detalleAgregar = new DetalleOrdenCompraServicio();
            detalleAgregar.setCantidad(detalle.getCantidad());
            detalleAgregar.setCantidadForm(detalle.getCantidadForm());
            detalleAgregar.setEstadoRegistro(ESTADO_REGISTRO.ACTIVO.getValor());
            detalleAgregar.setFecCreacion(detalle.getFecCreacion());
            detalleAgregar.setFecModificacion(detalle.getFecModificacion());
            detalleAgregar.setIdArticulo(detalle.getIdArticulo());
            detalleAgregar.setNombreArticulo(detalle.getIdArticulo().getNombreComercial());
            System.out.println(" unidad min: " + detalle.getIdTipoUnidadMinima().getId());
            detalleAgregar.setIdTipoUnidadMinima(detalle.getIdTipoUnidadMinima());
            detalleAgregar.setObservacion(detalle.getObservacion());
            detalleAgregar.setPrecio(detalle.getPrecio());
            detalleAgregar.setPrecioForm(detalle.getPrecioForm());
            detalleAgregar.setSubTotal(detalle.getSubTotal());
            detalleAgregar.setUnidadMedidaForm(detalle.getUnidadMedidaForm());
            detalleAgregar.setUsrCreacion(detalle.getUsrCreacion());
            detalleAgregar.setUsrModificacion(detalle.getUsrModificacion());
            detalleAgregar.setTotalRecibido(detalle.getTotalRecibido());
            if (bkOrdenCompra.getComando().getNombre().equalsIgnoreCase("Actualizar")) {
                detalleAgregar.setId(detalle.getId());
                detalleAgregar.setIdOrdenCompraServicio(detalle.getIdOrdenCompraServicio());
            }
            bkOrdenCompra.getListaDetalleOrdenCompraServicio().add(detalleAgregar);
            bkOrdenCompra.getListaTemporalDetalleOrdenCompraServicio().add(detalleAgregar);
        }


    }

    public String ver() {
        editar();
        return URLPaginacion.OrdenCompraServicio.URL_VER_ORDEN_COMPRA;
    }

    public String guardar() {
        OrdenCompraServicio ordenCS = bkOrdenCompra.getOrdenCompraFormulario();

        ordenCS.setFecCreacion(new Date());
        ordenCS.setUsrCreacion(session.getUsuario().getUsuario());
        ordenCS.setTipo(bkOrdenCompra.getTipoOrden());
        ordenCS.setEstadoOrden(bkOrdenCompra.getEstadoOrdenCompraServicio());

        try {
            ordenCS.setId(null);
            ordenCS.setUsrModificacion(null);
            ordenCS.setFecModificacion(null);
            bkOrdenCompra.getOrdenCompraFormulario().setFormaPago(
                    servicioFormaPago.conseguirTipoFormaPagoPorNombre(bkOrdenCompra.getOrdenCompraFormulario().getFormaPago().getNombre()));
            if (bkOrdenCompra.getOrdenCSAntigua() != null && bkOrdenCompra.getOrdenCompraFormulario().getCodigo().equalsIgnoreCase(bkOrdenCompra.getOrdenCSAntigua().getCodigo())) {
                bkOrdenCompra.getOrdenCompraFormulario().setCodigo("");
            }

            servicioOrdenCompra.guardarOrdenCompraServicio(ordenCS);
            if (bkOrdenCompra.getListaDetalleOrdenCompraServicio() != null) {
                for (DetalleOrdenCompraServicio detalle : bkOrdenCompra.getListaDetalleOrdenCompraServicio()) {
                    detalle.setId(null);
                    detalle.setIdOrdenCompraServicio(ordenCS);
                    detalle.setPartidaDespachoCollection(null);
                    detalle.setUsrModificacion(null);
                    detalle.setFecModificacion(null);
                    servicioDetalleOrdenCompra.guardarDetalleOrdenCompraServicio(detalle);

                }
            }

            mostrarMensaje("Se guardo la Orden de Compra satisfactoriamente.");
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al guardar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
        buscarListaOrdenCompras();
        /*if (ordenCS.getEstadoOrden().equalsIgnoreCase("" + OrdenCompraServicio.ESTADO_ORDEN_SC.ABIERTO.getValor())) {
         return ver();
         } else {
         return URLPaginacion.OrdenCompraServicio.URL_LISTA_ORDEN_COMPRA;
         }*/
        return ver();
        //return mostrarMantenimiento();
    }

    public String actualizar() {
        OrdenCompraServicio ordenCS = bkOrdenCompra.getOrdenCompraFormulario();

        ordenCS.setUsrModificacion(session.getUsuario().getUsuario());
        ordenCS.setFecModificacion(new Date());
        ordenCS.setTipo(bkOrdenCompra.getTipoOrden());
        ordenCS.setEstadoOrden(bkOrdenCompra.getEstadoOrdenCompraServicio());

        try {
            bkOrdenCompra.getOrdenCompraFormulario().setFormaPago(
                    servicioFormaPago.conseguirTipoFormaPagoPorNombre(bkOrdenCompra.getOrdenCompraFormulario().getFormaPago().getNombre()));
            //servicioOrdenCompra.actualizarOrdenCompraServicio(ordenCS);
            if (!bkOrdenCompra.getListaTemporalDetalleOrdenCompraServicio().isEmpty()) {
                for (DetalleOrdenCompraServicio detalle : bkOrdenCompra.getListaTemporalDetalleOrdenCompraServicio()) {
                    if (detalle.getId() == null) {
                        detalle.setIdOrdenCompraServicio(ordenCS);
                        //servicioDetalleOrdenCompra.guardarDetalleOrdenCompraServicio(detalle);
                    } /*else {
                     detalle.setIdOrdenCompraServicio(ordenCS);
                     //detalle.setFecModificacion(new Date());
                     //servicioDetalleOrdenCompra.actualizarDetalleOrdenCompraServicio(detalle);
                     }*/
                }
                ordenCS.setDetalleOrdenCompraServicioCollection(new ArrayList<DetalleOrdenCompraServicio>());
                ordenCS.getDetalleOrdenCompraServicioCollection().addAll(bkOrdenCompra.getListaTemporalDetalleOrdenCompraServicio());
            }

            servicioOrdenCompra.actualizarOrdenCompraServicio(ordenCS);

            mostrarMensaje("Se actualizo la Orden de Compra satisfactoriamente.");
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al actualizar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
        buscarListaOrdenCompras();
        /*if (ordenCS.getEstadoOrden().equalsIgnoreCase("" + OrdenCompraServicio.ESTADO_ORDEN_SC.ABIERTO.getValor())) {
         return ver();
         } else {
         return URLPaginacion.OrdenCompraServicio.URL_LISTA_ORDEN_COMPRA;
         }*/
        return ver();
        //return mostrarMantenimiento();
    }

    public void eliminar(ActionEvent actionEvent) {
        OrdenCompraServicio ordenCS = bkOrdenCompra.getOrdenCompraServicioSeleccionado();
        ordenCS.setEstadoRegistro(ESTADO_REGISTRO.INACTIVO.getValor());
        ordenCS.setUsrModificacion(session.getUsuario().getUsuario());
        ordenCS.setFecModificacion(new Date());
        try {
            servicioOrdenCompra.actualizarOrdenCompraServicio(ordenCS);
            buscarListaOrdenCompras();
            mostrarMensaje("Se elimino la Orden de Compra satisfactoriamente");
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al eliminar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
    }

    public String aceptar() {
        try {
            servicioOrdenCompra.actualizarOrdenCompraServicio(bkOrdenCompra.getOrdenCompraFormulario());
            bkOrdenCompra.setOrdenCompraFormulario(servicioOrdenCompra.conseguirOrdenCompraServicioPorId(1));
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al actualizar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
        return URLPaginacion.OrdenCompraServicio.URL_LISTA_ORDEN_COMPRA;
    }

    private void cargarCombo() {
        bkDetalleOrdenCompraServicio.setListaArticulo(null);
        bkDetalleOrdenCompraServicio.setIgvFormulario(null);
        try {
            bkDetalleOrdenCompraServicio.setIgvFormulario(servicioIgv.ConseguirIgvVigente());
            bkOrdenCompra.setListaTipoMoneda(servicioTipoMoneda.listarTipoMonedasActivos());

            /*bkOrdenCompra.setListaProveedor(new ArrayList<ProveedorTO>());
             bkOrdenCompra.setListarProveedorPorTipo(servicioProveedor.listarProveedorPorTipo());
             for (ProveedorTO to : bkOrdenCompra.getListarProveedorPorTipo()) {
             if (to.getTipo_insumo().equalsIgnoreCase("I")) {
             bkOrdenCompra.getListaProveedor().add(to);
             }
             }*/

            bkOrdenCompra.setListaSubCategoriaEcontrada(new ArrayList<CategoriaArticulo>());
            bkOrdenCompra.getListaSubCategoriaEcontrada().addAll(servicioCategoria.listarCategoriasHijos(null));
            bkOrdenCompra.setListaFormaPago(servicioFormaPago.obtenerTipoFormaPagoActivos());

        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
    }

    public Collection<OrdenPedido> buscarOrdenPedido(String ordenPedidoABuscar) {

        bkOrdenCompra.setEstaOrdenPedidoSeleccionado(false);
        Collection<OrdenPedido> listaOrdenesPedidoEncontrados = new ArrayList<OrdenPedido>();
        for (OrdenPedido ordenPedido : bkOrdenCompra.getListaOrdenesPedido()) {
            if (ordenPedido.getCodigoOrdenPedido().contains(ordenPedidoABuscar)) {
                listaOrdenesPedidoEncontrados.add(ordenPedido);
            }
        }
        return listaOrdenesPedidoEncontrados;

    }

    public List<String> buscarContacto(String contactoABuscar) {
        bkOrdenCompra.setEstaContactoSeleccionado(false);
        List<String> listaContactosEncontrados = new ArrayList<String>();
        for (Contacto contacto : bkOrdenCompra.getListaContacto()) {
            if (contacto.getNombre().contains(contactoABuscar)) {
                listaContactosEncontrados.add(contacto.getNombre());
            }
        }
        return listaContactosEncontrados;
    }

    public void elegirOP() {

        if (bkOrdenCompra.getComando().getNombre().equalsIgnoreCase("Guardar") && bkOrdenCompra.getOrdenCompraFormulario().getCodigo().isEmpty()) {
            //bkOrdenCompra.getOrdenCompraFormulario().setIdProveedor(null);
            bkOrdenCompra.getOrdenCompraFormulario().setIdCategoriaArticulo(new CategoriaArticulo());
            bkOrdenCompra.getListaSubCategoriaEcontrada().clear();
        }

        if (bkOrdenCompra.getOrdenCompraFormulario().getIdOrdenPedido() != null && bkOrdenCompra.getOrdenCompraFormulario().getIdOrdenPedido().getId() != 0) {

            try {
                bkOrdenCompra.getOrdenCompraFormulario().setIdOrdenPedido(
                        servicioOrdenPedido.conseguirOrdenPedidoPorId(bkOrdenCompra.getOrdenCompraFormulario().getIdOrdenPedido().getId()));
            } catch (ServiceException e) {
                logger.error(e.getMessage(), e);
                mostrarError("Ocurrio un error al cargar la informacion.");
            }

            if (bkOrdenCompra.getOrdenCompraFormulario().getIdOrdenPedido().getTipoOp() == 'T') {
                buscarArticulosCompPorPedidoTela(bkOrdenCompra.getOrdenCompraFormulario().getIdOrdenPedido());
            } else {
                buscarArticulosCompPorPedidoPrenda(bkOrdenCompra.getOrdenCompraFormulario().getIdOrdenPedido());
            }

            buscarCategorias();

        } else {

            try {
                bkOrdenCompra.getListaSubCategoriaEcontrada().addAll(servicioCategoria.listarCategoriasHijos(null));
            } catch (ServiceException e) {
                logger.error(e.getMessage(), e);
                mostrarError("Ocurrio un error al cargar la informacion.");
            }
            //seleccionarSubCategoria();
        }

    }

    public void buscarCategorias() {
        bkOrdenCompra.setListaSubCategoriaEcontrada(new ArrayList<CategoriaArticulo>());
        CategoriaArticulo categoriaAnt = null;

        for (Articulo articulo : this.bkOrdenCompra.getListaArticuloComp()) {
            boolean band = true;
            for (CategoriaArticulo categoria : bkOrdenCompra.getListaSubCategoriaEcontrada()) {
                if (categoria == articulo.getIdCategoriaArticulo()) {
                    band = false;
                    break;
                }
            }

            if (band) {
                bkOrdenCompra.getListaSubCategoriaEcontrada().add(articulo.getIdCategoriaArticulo());
            }

        }
    }

    public void seleccionarSubCategoria() {

        try {
            if (bkOrdenCompra.getOrdenCompraFormulario().getIdCategoriaArticulo().getId() != 0) {
                bkOrdenCompra.getOrdenCompraFormulario().setIdCategoriaArticulo(servicioCategoria.conseguirCategoriaArticuloPorId(bkOrdenCompra.getOrdenCompraFormulario().getIdCategoriaArticulo().getId()));
                System.out.println(bkOrdenCompra.getOrdenCompraFormulario().getIdCategoriaArticulo().getIdCategoriaArticulo().getNombre());
                if (bkOrdenCompra.getOrdenCompraFormulario().getIdOrdenPedido() != null
                        && bkOrdenCompra.getOrdenCompraFormulario().getIdOrdenPedido().getId() != null
                        && bkOrdenCompra.getOrdenCompraFormulario().getIdOrdenPedido().getId() != 0) {
                    buscarArticulosPorCategoria();
                } else {
                    Articulo articuloBusqueda = new Articulo();
                    articuloBusqueda.setIdCategoriaArticulo(bkOrdenCompra.getOrdenCompraFormulario().getIdCategoriaArticulo());
                    bkOrdenCompra.setListaArticuloCat(servicioArticulo.listarArticulosPorCategoria(articuloBusqueda));
                }

            }

        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }


    }

    public void buscarArticulosPorCategoria() {
        bkOrdenCompra.setListaArticuloCat(new ArrayList<Articulo>());
        List<Integer> ids = new ArrayList<Integer>();
        for (Articulo articulo : bkOrdenCompra.getListaArticuloComp()) {
            if (articulo.getIdCategoriaArticulo().getId().equals(bkOrdenCompra.getOrdenCompraFormulario().getIdCategoriaArticulo().getId())
                    && !ids.contains(articulo.getId())) {
                bkOrdenCompra.getListaArticuloCat().add(articulo);
                ids.add(articulo.getId());
            }

        }
    }

    public Collection<Proveedor> buscarProveedor(String proveedorABuscar) {
        Collection<Proveedor> listaProveerdorEncontrados = new ArrayList<Proveedor>();
        for (ProveedorTO to : bkOrdenCompra.getListaProveedor()) {
            if (to.getRazon_social().startsWith(proveedorABuscar)) {
                Proveedor proveedor = new Proveedor();
                proveedor.setId(to.getId());
                proveedor.setRazonSocial(to.getRazon_social());
                listaProveerdorEncontrados.add(proveedor);
            }
        }
        return listaProveerdorEncontrados;
    }

    public void elegirProveedor() {

        try {


            if (bkOrdenCompra.getOrdenCompraFormulario().getIdProveedor() != null) {
                bkOrdenCompra.getOrdenCompraFormulario().setDireccion(
                        bkOrdenCompra.getOrdenCompraFormulario().getIdProveedor().getDireccionLegal());


                bkOrdenCompra.getOrdenCompraFormulario().setIdTipoMoneda(bkOrdenCompra.getOrdenCompraFormulario().getIdProveedor().getIdTipoMoneda());

                Sede sede = new Sede();
                sede.setIdProveedor(bkOrdenCompra.getOrdenCompraFormulario().getIdProveedor());
                sede.setSedeAdministradora(1);
                bkOrdenCompra.setListaContacto(
                        servicioContacto.buscarContactosPorSede(
                        servicioSede.buscarSedeAdministradora(sede)));

            } else {
                bkOrdenCompra.getOrdenCompraFormulario().setDireccion(null);
                bkOrdenCompra.getOrdenCompraFormulario().getIdTipoMoneda().setId(0);
                bkOrdenCompra.setListaContacto(null);
            }
        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
    }

    public void seleccionarContacto() {
        try {

            if (bkOrdenCompra.getOrdenCompraFormulario().getContacto() != null) {
                for (Contacto contacto : bkOrdenCompra.getListaContacto()) {
                    if (contacto.getNombre().equalsIgnoreCase(bkOrdenCompra.getOrdenCompraFormulario().getContacto())) {
                        bkOrdenCompra.getOrdenCompraFormulario().setTelefono(contacto.getTelefono() + "/" + contacto.getMovil());
                    }
                }


            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }

    }

    public void marcarInicio(DateSelectEvent event) {
        bkOrdenCompra.getOrdenCompraFormulario().setFechaEmision(event.getDate());
        if (bkOrdenCompra.getOrdenCompraFormulario().getPlazoEntrega() != null) {
            bkOrdenCompra.getOrdenCompraFormulario().setDiasPlazo(UtilitarioFecha.restarFechas(bkOrdenCompra.getOrdenCompraFormulario().getPlazoEntrega(),
                    bkOrdenCompra.getOrdenCompraFormulario().getFechaEmision()));
        }
    }

    public void marcarFin(DateSelectEvent event) {

        bkOrdenCompra.getOrdenCompraFormulario().setPlazoEntrega(event.getDate());
        bkOrdenCompra.getOrdenCompraFormulario().setDiasPlazo(UtilitarioFecha.restarFechas(bkOrdenCompra.getOrdenCompraFormulario().getPlazoEntrega(),
                bkOrdenCompra.getOrdenCompraFormulario().getFechaEmision()));
    }

    @Override
    public String retroceder() {

        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public String cancelar() {
        //return mostrarMantenimiento();
        buscarListaOrdenCompras();
        return URLPaginacion.OrdenCompraServicio.URL_LISTA_ORDEN_COMPRA;
    }

    public void elegirFormaPago() {
        try {
            if (bkOrdenCompra.getOrdenCompraFormulario().getFormaPago().getNombre() != null) {

                bkOrdenCompra.setListaTipoPago(new ArrayList<String>());
                for (ParametroDetalle param : servicioParametro.listarTipoPago(bkOrdenCompra.getOrdenCompraFormulario().getFormaPago().getNombre())) {
                    bkOrdenCompra.getListaTipoPago().add(param.getValCadena());
                }
                bkOrdenCompra.getOrdenCompraFormulario().setDiasPago(null);
            }


        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }

    }

    /**
     * ******************************************* Busqueda de Antiguo
     * ***************************************************
     */
    public void inicializarBusquedaAntigua(ActionEvent actionEvent) {

        bkOrdenCompra.setOrdenPedidoBusqueda(new OrdenPedido(0));
        bkOrdenCompra.setListaOrdenCompraActivos(null);
        bkOrdenCompra.setOrdenCSAntigua(null);
        bkOrdenCompra.setIdOrdenCompraServicioAntigua(null);
        buscarListaOrdenComprasAntiguas();
    }

    public void buscarOrdenAntigua() {
        try {
            if (bkOrdenCompra.getIdOrdenCompraServicioAntigua() != 0) {
                bkOrdenCompra.setOrdenCSAntigua(servicioOrdenCompra.conseguirOrdenCompraServicioPorId(bkOrdenCompra.getIdOrdenCompraServicioAntigua()));
            } else {
                bkOrdenCompra.setOrdenCSAntigua(null);
            }
        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }

    }

    public void aplicarDatosAntiguos(ActionEvent actionEvent) {
        try {
            OrdenCompraServicio ordenC = servicioOrdenCompra.conseguirOrdenCompraServicioPorId(bkOrdenCompra.getOrdenCSAntigua().getId());

            bkOrdenCompra.setOrdenCompraFormulario(ordenC);
            //bkOrdenCompra.getOrdenCompraFormulario().setCodigo("");
            //iniciarEdicion();

            cargarCombo();
            iniciarEdicion(ordenC);
            elegirOP();
            seleccionarSubCategoria();
            elegirProveedor();
            if (bkOrdenCompra.getOrdenCompraFormulario().getIdOrdenPedido() == null) {
                bkOrdenCompra.getOrdenCompraFormulario().setIdOrdenPedido(new OrdenPedido());
            }
        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
    }

    @Override
    public void actualizarObservador(Object object) {
        if (object instanceof Map) {
            Map<String, Object> datos = (Map<String, Object>) object;
            Sede sede = (Sede) datos.get("sede");

            bkOrdenCompra.getOrdenCompraFormulario().setLugarEntrega(sede.getDireccion());
        }

        if (object instanceof Proveedor) {
            try {
                Proveedor proveedor = servicioProveedor.conseguirProveedorPorId(((Proveedor) object).getId());
                bkOrdenCompra.getOrdenCompraFormulario().setIdProveedor(proveedor);
                elegirProveedor();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public String emitirOrden() {

        String format = "%1$03d";

        bkOrdenCompra.setEstadoOrdenCompraServicio("" + OrdenCompraServicio.ESTADO_ORDEN_SC.ABIERTO.getValor());
        Integer numero = 0;
        try {
            numero = servicioOrdenCompra.buscarCantidadOC(bkOrdenCompra.getOrdenCompraFormulario());
            System.out.println("numero1: " + numero);
            if (numero == 0) {

                bkOrdenCompra.getOrdenCompraFormulario().setCodigo("OC-"
                        + bkOrdenCompra.getOrdenCompraFormulario().getIdCategoriaArticulo().getIdCategoriaArticulo().getCodigo() + "001-"
                        + UtilitarioFecha.obtenerAnio(bkOrdenCompra.getOrdenCompraFormulario().getFechaEmision()));

            } else {
                numero++;
                System.out.println("numero2: " + numero);
                bkOrdenCompra.getOrdenCompraFormulario().setCodigo("OC-"
                        + bkOrdenCompra.getOrdenCompraFormulario().getIdCategoriaArticulo().getIdCategoriaArticulo().getCodigo() + String.format(format, numero)
                        + "-" + UtilitarioFecha.obtenerAnio(bkOrdenCompra.getOrdenCompraFormulario().getFechaEmision()));

            }

        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
        mostrarMensaje("Su Orden de Compra ahora ha sido emitida");
        bkOrdenCompra.getOrdenCompraFormulario().setUsrEmision(session.getUsuario().getNombres() + " " + session.getUsuario().getApellidos());
        if (bkOrdenCompra.getComando().getNombre().equalsIgnoreCase("Guardar")) {
            return guardar();
        } else {
            return actualizar();
        }

    }

    public String emitirOrdenAntiguo() {

        CorrelativoDocumento correlativo = new CorrelativoDocumento();
        correlativo.setAnio(UtilitarioFecha.obtenerAnioActual());

        TipoDocumento tipoDocumento = new TipoDocumento();
        tipoDocumento.setNombre(Constantes.TipoDocumento.TIPO_DOC_ORDEN_COMPRA);

        String format = "%1$05d";

        bkOrdenCompra.setEstadoOrdenCompraServicio("" + OrdenCompraServicio.ESTADO_ORDEN_SC.ABIERTO.getValor());
        Integer numero = 0;
        try {
            correlativo.setIdTipoDocumento(servicioTipoDocumento.obtenerTipoDocumentoPorNombre(tipoDocumento));
            correlativo.setIdsede(session.getSede());
            CorrelativoDocumento correlativoEncontrado = servicioCorrelativo.obtenerCorrelativoDocumentoPorAnio(correlativo);
            if (correlativoEncontrado == null) {

                correlativo.setUsrCreacion(session.getUsuario().getUsuario());
                correlativo.setFecCreacion(new Date());
                correlativo.setNumero("00002");
                servicioCorrelativo.guardarCorrelativoDocumento(correlativo);
                bkOrdenCompra.getOrdenCompraFormulario().setCodigo("OC-00001-" + correlativo.getAnio());

            } else {

                correlativo = correlativoEncontrado;
                numero = Integer.parseInt(correlativo.getNumero());
                bkOrdenCompra.getOrdenCompraFormulario().setCodigo("OC-" + String.format(format, numero) + "-" + correlativo.getAnio());
                numero++;
                correlativo.setNumero(String.format(format, numero));
                correlativo.setUsrModificacion(session.getUsuario().getUsuario());
                correlativo.setFecModificacion(new Date());
                servicioCorrelativo.actualizarCorrelativoDocumento(correlativo);

            }

        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
        mostrarMensaje("Su Orden de Compra ahora ha sido emitida");
        bkOrdenCompra.getOrdenCompraFormulario().setUsrEmision(session.getUsuario().getNombres() + " " + session.getUsuario().getApellidos());
        if (bkOrdenCompra.getComando().getNombre().equalsIgnoreCase("Guardar")) {
            return guardar();
        } else {
            return actualizar();
        }

    }

    public void elegirMoneda() {
        try {
            bkOrdenCompra.getOrdenCompraFormulario().setIdTipoMoneda(
                    servicioTipoMoneda.conseguirTipoMonedaPorId(bkOrdenCompra.getOrdenCompraFormulario().getIdTipoMoneda().getId()));
        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }

    }
}
